package com.lmf.sparseArray;

/**
 * 实现二维数组与稀疏数组之间的互相转换
 */
public class SparseArray {
    public static void main(String[] args) {
        /**
         * 实现将一个二维数组转化为一个稀疏数组案例：
         */
        //一.创建一个原始二维数组chessArr1：   1：表示黑子  2：表示白子
        int[][] chessArr1 = new int[11][11];
        //给二维数组中赋值：表示棋盘上不同位置的棋子
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        chessArr1[4][5] = 2;
        chessArr1[5][6] = 1;
        //遍历打印输出这个二维数组
        System.out.println("这是一个二维数组：表示一个11*11的棋盘");
        for (int[] row : chessArr1) {
            for (int col : row) {
                //进行格式化输出，是printf()方法，不是println()方法
                System.out.printf("%d\t",col);
            }
            //每输出一个一维数组后换行
            System.out.println();
        }

        //二.将二维数组转换为一个稀疏数组
        //1.先遍历原始二维数组，得到其中所有“非0数据”个数
        int sum = 0;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1.length; j++) {
                if (chessArr1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("原始数组中非零数据个数："+sum);
        System.out.println("----------------------");

        //2.创建对应的稀疏数组
        int[][] sparseArr = new int[sum+1][3];
        //给稀疏数组第一行赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        //将二维数组的非零数据，存放到稀疏数组中
        int count = 0;  //记录稀疏数组存放数据的行数
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1.length; j++) {
                if (chessArr1[i][j] != 0) {
                    //在二维数组中遍历到非零数据，就存放到稀疏数组中
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        //遍历打印稀疏数组
        System.out.println("这是对应稀疏数组：");
        for (int[] row : sparseArr) {
            for (int col : row) {
                System.out.printf("%d\t",col);
            }
            System.out.println();
        }

        /**
         * 实现一个稀疏数组转化为一个原始的二维数组案例：
         *      // 1 读取稀疏数组的第一行 根据第一行的数据,  创建原始的二维数组
         * 		// 2 在读取稀疏数组的后几行 并赋值
         */
        //遍历稀疏数组，将其中记录的数据，恢复到一个二维数组中去
        int[][] chessArr2 = null;  //创建一个二维数组变量
        for (int i = 0; i < sparseArr.length; i++) {
            for (int j = 0; j < sparseArr.length; j++) {
                //若i为第一行，则创建一个二维数组
                if (i == 0) {
                    //行
                    int row = sparseArr[i][0];
                    //列
                    int col = sparseArr[i][1];
                    //给二维数组创建实例
                    chessArr2 = new int[row][col];
                }else {
                    //若i为其他行，则给二维数组赋值
                    //行
                    int row = sparseArr[i][0];
                    //列
                    int col = sparseArr[i][1];
                    //值
                    int val = sparseArr[i][2];
                    //给二维数组赋值
                    chessArr2[row][col] = val;
                }
            }
        }
        // 遍历打印恢复的二维数组
        System.out.println("这是恢复的二维数组：");
        for (int[] row : chessArr2) {
            for (int col : row) {
                System.out.printf("%d\t",col);
            }
            //换行
            System.out.println();
        }
    }
}
